﻿using System.Data;

namespace Epm.AppLogic.Framework
{
    public class CustBizObject : CBizObject
    {
        public CustBizObject()
            : base()
        {
        }
        /// <summary>
        /// 构造函数获取OperatorID
        /// </summary>
        public CustBizObject(DataTable _dttem, string _strTableName, string _strKeyFieldName)
            : base()
        {
            if (string.IsNullOrEmpty(_strTableName))
            {
                _strTableName = _dttem.TableName;
            }
            this.DataObj = new CDbAccess();
            this.DataObj.Init(_dttem);
            this.DataObj.TableName = _strTableName;
            this.TableName = _strTableName;
            this.DataObj.KeyField = this.DataObj.Fields[_strKeyFieldName];
        }
        CustDataChangeAlc oCustDataChangeAlc = new CustDataChangeAlc();
        /// <summary>
        /// 在BeforeRowAdded之后，BeforeRowModified1之前，BeforeRowDeleted1之前，实际执行SQL新增之前进行处理,如果需要处理,请重载该函数
        /// </summary>
        /// <param name="drw">修改后的记录（以DATAROW表示）</param>
        /// <returns>如果处理完成，返回TRUE</returns>

        protected sealed override bool BeforeRowUpdate1(DataRow drw)
        {
            BeforeRowUpdate(drw);
            return base.BeforeRowUpdate1(drw); 
        }

        /// <summary>
        /// 在增加记录前对该条记录进行校验,如果需要校验,请重载该函数
        /// </summary>
        /// <param name="drw">需要增加的记录（以DataRow表示）</param>
        /// <returns>如果校验通过，返回TRUE</returns>

        protected sealed override bool BeforeRowAdded1(DataRow drw)
        {
            BeforeRowAdded(drw);
            return base.BeforeRowAdded1(drw); 
        }
        /// <summary>
        /// 在增加记录后对进行后续处理,如果需要后续处理,请重载该函数
        /// </summary>
        /// <param name="drw">增加后的记录（以DataRow表示）</param>
        /// <returns>如果处理完成，返回TRUE</returns>

        protected sealed override bool AfterRowAdded1(DataRow drw)
        {
            AfterRowAdded(drw);
            return base.AfterRowAdded1(drw); 
        }
        /// <summary>
        /// 在修改记录前对该条记录进行处理,如果需要处理,请重载该函数
        /// </summary>
        /// <param name="drw">需要修改的记录（以DATAROW表示）</param>
        /// <returns>如果校验通过，返回TRUE</returns>

        protected sealed override bool BeforeRowModified1(DataRow drw)
        {
            BeforeRowModified(drw);
            return base.BeforeRowModified1(drw); 
        }
        /// <summary>
        /// 在修改记录后对进行处理,如果需要处理,请重载该函数
        /// </summary>
        /// <param name="drw">修改后的记录（以DATAROW表示）</param>
        /// <returns>如果处理完成，返回TRUE</returns>

        protected sealed override bool AfterRowModified1(DataRow drw)
        {
            AfterRowModified(drw);
            return base.AfterRowModified1(drw); 
        }

        /// <summary>
        /// 在实际SQL新增之后，AfterRowDeleted1之前，AfterRowAdded1之前，AfterRowModified1之前进行处理,如果需要处理,请重载该函数
        /// </summary>
        /// <param name="drw">修改后的记录（以DATAROW表示）</param>
        /// <returns>如果处理完成，返回TRUE</returns>

        protected sealed override bool AfterRowUpdate1(DataRow drw)
        {
            AfterRowUpdate(drw);
            oCustDataChangeAlc.doSnyToBsc(drw, this);
            return base.AfterRowUpdate1(drw); 
        }


        /// <summary>
        /// 在删除记录之前对该条记录进行的校验,如果需要校验,请重载该函数
        /// </summary>
        /// <param name="drw">需要校验的DATAROW</param>
        /// <returns>校验通过返回TRUE,默认返回TRUE</returns>

        protected sealed override bool BeforeRowDeletedR1(DataRow drw)
        {
            BeforeRowDeletedR(drw);
            return base.BeforeRowDeletedR1(drw); 
        }


        /// <summary>
        /// 在删除记录之前对该条记录进行的校验,如果需要校验,请重载该函数
        /// </summary>
        /// <param name="drw">需要校验的DATAROW</param>
        /// <returns>校验通过返回TRUE,默认返回TRUE</returns>

        protected sealed override bool BeforeRowDeleted1(string strRowKeyValue)
        {
            BeforeRowDeleted(strRowKeyValue);
            return base.BeforeRowDeleted1(strRowKeyValue); 
        }
        /// <summary>
        /// 在删除记录之后对该条记录进行的后续处理,如果需要后续处理,请重载该函数
        /// </summary>
        /// <param name="drw">DATAROW</param>
        /// <returns>后续处理完返回TRUE,默认返回TRUE</returns>

        protected sealed override bool AfterRowDeleted1(string strRowKeyValue)
        {
            AfterRowDeleted(strRowKeyValue);
            return base.AfterRowDeleted1(strRowKeyValue); 
        }
        /// <summary>
        /// 在删除记录之后对该条记录进行的后续处理,如果需要后续处理,请重载该函数
        /// </summary>
        /// <param name="drw">DATAROW</param>
        /// <returns>后续处理完返回TRUE,默认返回TRUE</returns>

        protected sealed override bool AfterRowDeletedR1(DataRow drw)
        {
            AfterRowDeletedR(drw);
            return base.AfterRowDeletedR1(drw); 
        }





        #region   虚拟数据更改事件接口

        /////////////////////////////////////////////////////////////////////////

        /// <summary>
        /// 在BeforeRowAdded之后，实际执行SQL新增之前进行处理,如果需要处理,请重载该函数
        /// </summary>
        /// <param name="drw">修改后的记录（以DATAROW表示）</param>
        /// <returns>如果处理完成，返回TRUE</returns>

        protected virtual bool BeforeRowUpdate(DataRow drw)
        {
            return true;
        }

        /// <summary>
        /// 在增加记录前对该条记录进行校验,如果需要校验,请重载该函数
        /// </summary>
        /// <param name="drw">需要增加的记录（以DataRow表示）</param>
        /// <returns>如果校验通过，返回TRUE</returns>

        protected virtual bool BeforeRowAdded(DataRow drw)
        {
            return true;
        }
        /// <summary>
        /// 在增加记录后对进行后续处理,如果需要后续处理,请重载该函数
        /// </summary>
        /// <param name="drw">增加后的记录（以DataRow表示）</param>
        /// <returns>如果处理完成，返回TRUE</returns>

        protected virtual bool AfterRowAdded(DataRow drw)
        {
            return true;
        }
        /// <summary>
        /// 在修改记录前对该条记录进行处理,如果需要处理,请重载该函数
        /// </summary>
        /// <param name="drw">需要修改的记录（以DATAROW表示）</param>
        /// <returns>如果校验通过，返回TRUE</returns>

        protected virtual bool BeforeRowModified(DataRow drw)
        {
            return true;
        }
        /// <summary>
        /// 在修改记录后对进行处理,如果需要处理,请重载该函数
        /// </summary>
        /// <param name="drw">修改后的记录（以DATAROW表示）</param>
        /// <returns>如果处理完成，返回TRUE</returns>

        protected virtual bool AfterRowModified(DataRow drw)
        {
            return true;
        }

        /// <summary>
        /// 在实际SQL新增之后，AfterRowAdded之前进行处理,如果需要处理,请重载该函数
        /// </summary>
        /// <param name="drw">修改后的记录（以DATAROW表示）</param>
        /// <returns>如果处理完成，返回TRUE</returns>

        protected virtual bool AfterRowUpdate(DataRow drw)
        {
            return true;
        }


        /// <summary>
        /// 在删除记录之前对该条记录进行的校验,如果需要校验,请重载该函数
        /// </summary>
        /// <param name="drw">需要校验的DATAROW</param>
        /// <returns>校验通过返回TRUE,默认返回TRUE</returns>

        protected virtual bool BeforeRowDeletedR(DataRow drw)
        {
            return true;
        }


        /// <summary>
        /// 在删除记录之前对该条记录进行的校验,如果需要校验,请重载该函数
        /// </summary>
        /// <param name="drw">需要校验的DATAROW</param>
        /// <returns>校验通过返回TRUE,默认返回TRUE</returns>

        protected virtual bool BeforeRowDeleted(string strRowKeyValue)
        {
            return true;
        }
        /// <summary>
        /// 在删除记录之后对该条记录进行的后续处理,如果需要后续处理,请重载该函数
        /// </summary>
        /// <param name="drw">DATAROW</param>
        /// <returns>后续处理完返回TRUE,默认返回TRUE</returns>

        protected virtual bool AfterRowDeleted(string strRowKeyValue)
        {
            return true;
        }
        /// <summary>
        /// 在删除记录之后对该条记录进行的后续处理,如果需要后续处理,请重载该函数
        /// </summary>
        /// <param name="drw">DATAROW</param>
        /// <returns>后续处理完返回TRUE,默认返回TRUE</returns>

        protected virtual bool AfterRowDeletedR(DataRow drw)
        {
            return true;
        }


        #endregion


    }
}
